package com.gensdai.leliang.retrofitUtils;

import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.ObservableTransformer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.annotations.NonNull;
import io.reactivex.schedulers.Schedulers;


/**
 * Created by zsxx on 2017/6/19.
 */

public class ModelFilteredFactory<T> {


    /**
     * 这里就不细讲了,具体可以去看rxjava的使用.这个类的意义就是转换Observable.
     */
//    private static class SimpleTransformer<T> implements ObservableTransformer<BaseParse<T>, T> {
//        //这里对Observable,进行一般的通用设置.不用每次用Observable都去设置线程以及重连设置
//        @Override
//        public Observable<T> call(Observable<BaseParse<T>> observable) {
//            return observable.subscribeOn(Schedulers.io())
//                    .observeOn(AndroidSchedulers.mainThread())
//                    .unsubscribeOn(Schedulers.io())
//                    .timeout(5, TimeUnit.SECONDS)//重连间隔时间
//                    .retry(5)//重连次数
//                    .flatMap(new Function<BaseParse<T>, ObservableSource<?>>() {
//                        @Override
//                        public ObservableSource<?> apply(@NonNull BaseParse<T> tBaseParse) throws Exception {
//                            return null;
//                        }
//                    });
//        }
//
//    }


    private final static ObservableTransformer transformer = new SimpleTransformer();

    /**
     * 将Observable<BaseResponse<T>>转化Observable<T>,并处理BaseResponse
     *
     * @return 返回过滤后的Observable.
     */
    @SuppressWarnings("unchecked")
    public static <T> Observable<T> compose(Observable<T> observable) {
        return observable.compose(transformer);
    }

    private static class SimpleTransformer<T> implements ObservableTransformer<T, T> {

        @Override
        public ObservableSource<T> apply(@NonNull Observable<T> upstream) {
            return upstream
                    .subscribeOn(Schedulers.io())     //subscribeOn() 指定的是上游发送事件的线程  多次指定上游的线程只有第一次指定的有效, 也就是说多次调用subscribeOn() 只有第一次的有效, 其余的会被忽略.
                    .observeOn(AndroidSchedulers.mainThread())  //observeOn() 指定的是下游接收事件的线程. 多次指定下游的线程是可以的, 也就是说每调用一次observeOn() , 下游的线程就会切换一次.
                    .unsubscribeOn(Schedulers.io())
                    .timeout(30, TimeUnit.SECONDS)//重连间隔时间
                    .retry(2)//重连次数
                    ;
        }
    }

}
